ટાઇપસ્ક્રિપ્ટ ટેમ્પલેટ લિટરલ વેલિડેશન એન્જિન: રનટાઇમ સ્ટ્રિંગ વેરિફિકેશન

ટાઇપસ્ક્રિપ્ટના ટેમ્પલેટ લિટરલ ટાઇપ્સ શક્તિશાળી કમ્પાઇલ-ટાઇમ સ્ટ્રિંગ મેનિપ્યુલેશન અને ટાઇપ સેફ્ટી પ્રદાન કરે છે. જોકે, આ ચકાસણીઓ ફક્ત કમ્પાઇલ ટાઇમ પૂરતી મર્યાદિત છે. આ બ્લોગ પોસ્ટમાં ટાઇપસ્ક્રિપ્ટ ટેમ્પલેટ લિટરલ ટાઇપ્સ માટે રનટાઇમ વેલિડેશન એન્જિન કેવી રીતે બનાવવું તે શોધવામાં આવ્યું છે, જે મજબૂત સ્ટ્રિંગ વેરિફિકેશનને સક્ષમ કરે છે અને પ્રોગ્રામ એક્ઝેક્યુશન દરમિયાન સંભવિત ભૂલોને અટકાવે છે.

ટાઇપસ્ક્રિપ્ટ ટેમ્પલેટ લિટરલ ટાઇપ્સનો પરિચય

ટેમ્પલેટ લિટરલ ટાઇપ્સ તમને લિટરલ વેલ્યુઝ, યુનિયન્સ અને ટાઇપ ઇન્ફરન્સ પર આધારિત ચોક્કસ સ્ટ્રિંગ આકાર વ્યાખ્યાયિત કરવાની મંજૂરી આપે છે. આ ચોક્કસ ટાઇપ ચેકિંગ અને ઓટો-કમ્પ્લીશનને સક્ષમ કરે છે, ખાસ કરીને જ્યારે સ્ટ્રક્ચર્ડ ડેટા અથવા ડોમેન-સ્પેસિફિક લેંગ્વેજ સાથે કામ કરતી વખતે તે ઉપયોગી છે.

ઉદાહરણ તરીકે, કરન્સી કોડ્સને રજૂ કરવા માટે એક ટાઇપનો વિચાર કરો:

            
type CurrencyCode = "USD" | "EUR" | "GBP";

type FormattedCurrencyString = `${CurrencyCode}-${number}`;

const validCurrency: FormattedCurrencyString = "USD-100"; // OK
const invalidCurrency: FormattedCurrencyString = "CAD-50"; // Type error at compile time

            

              
                Copy
              
            
          

આ ઉદાહરણ બતાવે છે કે ટાઇપસ્ક્રિપ્ટ કમ્પાઇલ ટાઇમ પર FormattedCurrencyString ટાઇપને કેવી રીતે લાગુ કરે છે. જોકે, જો કરન્સી કોડ બાહ્ય સ્ત્રોત (દા.ત., યુઝર ઇનપુટ, API રિસ્પોન્સ) માંથી આવે છે, તો તમારે ટાઇપ સેફ્ટી સુનિશ્ચિત કરવા માટે રનટાઇમ વેલિડેશનની જરૂર છે.

રનટાઇમ વેલિડેશનની જરૂરિયાત

જ્યારે ટાઇપસ્ક્રિપ્ટ ઉત્તમ કમ્પાઇલ-ટાઇમ ટાઇપ ચેકિંગ પ્રદાન કરે છે, તે રનટાઇમ પર બાહ્ય સ્ત્રોતોમાંથી મળેલા ડેટાની માન્યતાની ગેરંટી આપી શકતું નથી. ફક્ત કમ્પાઇલ-ટાઇમ ટાઇપ્સ પર આધાર રાખવાથી અનપેક્ષિત ભૂલો અને નબળાઈઓ થઈ શકે છે.

નીચેની પરિસ્થિતિનો વિચાર કરો:

            
function processCurrency(currencyString: FormattedCurrencyString) {
  // ... some logic that assumes the string is correctly formatted
}

const userInput = "CAD-50"; // Assume this comes from user input

// This will compile, but will cause a runtime error if the logic inside
// `processCurrency` relies on the format.
processCurrency(userInput as FormattedCurrencyString);

            

              
                Copy
              
            
          

આ કિસ્સામાં, અમે userInput ને FormattedCurrencyString માં કાસ્ટ કરી રહ્યા છીએ, જે ટાઇપસ્ક્રિપ્ટના કમ્પાઇલ-ટાઇમ ચેક્સને બાયપાસ કરે છે. જો processCurrency સ્ટ્રિંગના સાચા ફોર્મેટ પર આધાર રાખે છે, તો તે રનટાઇમ ભૂલનો સામનો કરશે.

રનટાઇમ વેલિડેશન આ ગેપને પૂરો પાડે છે અને ખાતરી કરે છે કે રનટાઇમ પર મળેલો ડેટા અપેક્ષિત ટાઇપસ્ક્રિપ્ટ ટાઇપ્સને અનુરૂપ છે.

ટેમ્પલેટ લિટરલ વેલિડેશન એન્જિન બનાવવું

અમે રેગ્યુલર એક્સપ્રેશન્સ અને ટાઇપસ્ક્રિપ્ટના ટાઇપ સિસ્ટમનો ઉપયોગ કરીને રનટાઇમ વેલિડેશન એન્જિન બનાવી શકીએ છીએ. આ એન્જિન ઇનપુટ તરીકે ટેમ્પલેટ લિટરલ ટાઇપ અને એક સ્ટ્રિંગ લેશે અને સ્ટ્રિંગ ટાઇપ સાથે મેળ ખાય છે કે નહીં તે પરત કરશે.

પગલું 1: રનટાઇમ વેલિડેશન માટે ટાઇપ વ્યાખ્યાયિત કરવું

પ્રથમ, આપણને એક જેનરિક ટાઇપની જરૂર છે જે ટેમ્પલેટ લિટરલ ટાઇપના રનટાઇમ સમકક્ષને રજૂ કરી શકે. આ ટાઇપ લિટરલ્સ, યુનિયન્સ અને ટાઇપ પેરામીટર્સ સહિત વિવિધ પ્રકારના ટેમ્પલેટ લિટરલ્સને હેન્ડલ કરવા સક્ષમ હોવો જોઈએ.

            
type TemplateLiteralToRegex = 
  T extends `${infer Start}${infer Middle}${infer End}`
    ? Start extends string
      ? Middle extends string
        ? End extends string
          ? TemplateLiteralToRegexStart & TemplateLiteralToRegexMiddle & TemplateLiteralToRegex
          : never
        : never
      : never
    : TemplateLiteralToRegexStart;


type TemplateLiteralToRegexStart = T extends `${infer Literal}` ? Literal : string;

type TemplateLiteralToRegexMiddle = T extends `${infer Literal}` ? Literal : string;

            

              
                Copy
              
            
          

આ રિકર્સિવ ટાઇપ ડેફિનેશન ટેમ્પલેટ લિટરલને તેના ઘટક ભાગોમાં વિભાજિત કરે છે અને દરેક ભાગને રેગ્યુલર એક્સપ્રેશન પેટર્નમાં રૂપાંતરિત કરે છે.

પગલું 2: વેલિડેશન ફંક્શનનો અમલ

આગળ, અમે વેલિડેશન ફંક્શનનો અમલ કરીએ છીએ જે ઇનપુટ તરીકે ટેમ્પલેટ લિટરલ ટાઇપ અને વેલિડેટ કરવાની સ્ટ્રિંગ લે છે. આ ફંક્શન સ્ટ્રિંગને ટેસ્ટ કરવા માટે TemplateLiteralToRegex દ્વારા જનરેટ થયેલ રેગ્યુલર એક્સપ્રેશનનો ઉપયોગ કરે છે.

            
function isValid(str: string, templateType: T): boolean {
  const regexPattern = `^${convertTemplateLiteralToRegex(templateType)}$`;
  const regex = new RegExp(regexPattern);
  return regex.test(str);
}

function convertTemplateLiteralToRegex(templateType: T): string {
  // Basic conversion for literal strings - extend this for more complex scenarios
  return templateType.replace(/[.*+?^${}()|[\]]/g, '\\$&'); // Escape special regex characters
}

            

              
                Copy
              
            
          

આ ફંક્શન ખાસ રેગ્યુલર એક્સપ્રેશન કેરેક્ટર્સને એસ્કેપ કરે છે અને ટેમ્પલેટ લિટરલ ટાઇપમાંથી રેગ્યુલર એક્સપ્રેશન બનાવે છે, પછી તે રેગ્યુલર એક્સપ્રેશન સામે સ્ટ્રિંગનું પરીક્ષણ કરે છે.

પગલું 3: વેલિડેશન એન્જિનનો ઉપયોગ

હવે, તમે તમારા ટેમ્પલેટ લિટરલ ટાઇપ્સ સામે રનટાઇમ પર સ્ટ્રિંગ્સને વેલિડેટ કરવા માટે isValid ફંક્શનનો ઉપયોગ કરી શકો છો.

            
type CurrencyCode = "USD" | "EUR" | "GBP";

type FormattedCurrencyString = `${CurrencyCode}-${number}`;

const userInput1 = "USD-100";
const userInput2 = "CAD-50";

console.log(`'${userInput1}' is valid: ${isValid(userInput1, "USD-100" )}`); // true
console.log(`'${userInput2}' is valid: ${isValid(userInput2, "USD-100")}`); // false

console.log(`'${userInput1}' is valid: ${isValid(userInput1, `USD-${100}`)}`); // true
console.log(`'${userInput2}' is valid: ${isValid(userInput2, `USD-${100}`)}`); // false


            

              
                Copy
              
            
          

આ ઉદાહરણ FormattedCurrencyString ટાઇપ સામે યુઝર ઇનપુટને વેલિડેટ કરવા માટે isValid ફંક્શનનો ઉપયોગ કેવી રીતે કરવો તે દર્શાવે છે. આઉટપુટ બતાવશે કે ઇનપુટ સ્ટ્રિંગ્સ નિર્દિષ્ટ ટેમ્પલેટ લિટરલના આધારે માન્ય છે કે નહીં.

એડવાન્સ્ડ વેલિડેશન સિનારિયોઝ

મૂળભૂત વેલિડેશન એન્જિનને વધુ જટિલ સિનારિયોઝ, જેમ કે યુનિયન્સ, કન્ડિશનલ ટાઇપ્સ અને રિકર્સિવ ટાઇપ્સને હેન્ડલ કરવા માટે વિસ્તૃત કરી શકાય છે.

યુનિયન્સને હેન્ડલ કરવું

યુનિયન્સને હેન્ડલ કરવા માટે, તમે TemplateLiteralToRegex ટાઇપને સુધારી શકો છો જેથી તે એક રેગ્યુલર એક્સપ્રેશન જનરેટ કરે જે યુનિયનના કોઈપણ સભ્ય સાથે મેળ ખાય.

            
type CurrencyCode = "USD" | "EUR" | "GBP";

type FormattedCurrencyString = `${CurrencyCode}-${number}`;

function isValidCurrencyCode(str: string, templateType: T): boolean {
    const currencyCodes: CurrencyCode[] = ["USD", "EUR", "GBP"];
    return currencyCodes.includes(str as CurrencyCode);
}


function isValidUnionFormattedCurrencyString(str: string): boolean {
    const parts = str.split('-');
    if(parts.length !== 2) return false;
    const [currencyCode, amount] = parts;

    if (!isValidCurrencyCode(currencyCode, currencyCode)) return false;

    if (isNaN(Number(amount))) return false;

    return true;
}

console.log(`'USD-100' is valid formatted string: ${isValidUnionFormattedCurrencyString('USD-100')}`);
console.log(`'CAD-50' is valid formatted string: ${isValidUnionFormattedCurrencyString('CAD-50')}`);


            

              
                Copy
              
            
          

કન્ડિશનલ ટાઇપ્સને હેન્ડલ કરવું

કન્ડિશનલ ટાઇપ્સને રનટાઇમ પર શરતનું મૂલ્યાંકન કરીને અને પરિણામના આધારે જુદા જુદા રેગ્યુલર એક્સપ્રેશન્સ જનરેટ કરીને હેન્ડલ કરી શકાય છે.

            
type IsString = T extends string ? true : false;

// This example requires more advanced logic and isn't fully implementable using simple regex.
// Runtime type guards offer a more robust solution in this specific scenario.
// The below code is illustrative and would need adaptation to handle complex conditional types.

function isString(value: any): value is string {
    return typeof value === 'string';
}

function isValidConditionalType(value: any): boolean {
    return isString(value);
}

console.log(`'hello' is a string: ${isValidConditionalType('hello')}`);
console.log(`123 is a string: ${isValidConditionalType(123)}`);

            

              
                Copy
              
            
          

રિકર્સિવ ટાઇપ્સને હેન્ડલ કરવું

રિકર્સિવ ટાઇપ્સને રિકર્સિવ ફંક્શન વ્યાખ્યાયિત કરીને હેન્ડલ કરી શકાય છે જે રેગ્યુલર એક્સપ્રેશન પેટર્ન જનરેટ કરે છે. જોકે, અનંત રિકર્ઝન અને સ્ટેક ઓવરફ્લો ભૂલોથી બચવા માટે સાવચેત રહો. ઊંડા રિકર્ઝન માટે, યોગ્ય મર્યાદાઓ સાથે ઇટરેટિવ અભિગમો મહત્વપૂર્ણ છે.

રેગ્યુલર એક્સપ્રેશન્સના વિકલ્પો

જ્યારે રેગ્યુલર એક્સપ્રેશન્સ સ્ટ્રિંગ વેલિડેશન માટે એક શક્તિશાળી સાધન છે, ત્યારે તે જટિલ અને જાળવવા મુશ્કેલ હોઈ શકે છે. રનટાઇમ વેલિડેશનના અન્ય અભિગમોમાં શામેલ છે:

• કસ્ટમ વેલિડેશન ફંક્શન્સ: તમારી એપ્લિકેશનની જરૂરિયાતોને આધારે ચોક્કસ ટાઇપ્સને વેલિડેટ કરવા માટે કસ્ટમ ફંક્શન્સ લખો.
• ટાઇપ ગાર્ડ્સ: રનટાઇમ પર વેરિયેબલના ટાઇપને સંકુચિત કરવા માટે ટાઇપ ગાર્ડ્સનો ઉપયોગ કરો.
• વેલિડેશન લાઇબ્રેરીઝ: વેલિડેશન પ્રક્રિયાને સરળ બનાવવા માટે Zod અથવા Yup જેવી હાલની વેલિડેશન લાઇબ્રેરીઓનો લાભ લો.

ઉદાહરણ તરીકે, Zod એક સ્કીમા-આધારિત ઘોષણા પ્રદાન કરે છે જે વેલિડેશન રનટાઇમમાં અનુવાદિત થાય છે:

            
import { z } from 'zod';

const CurrencyCodeSchema = z.enum(['USD', 'EUR', 'GBP']);
const FormattedCurrencyStringSchema = z.string().regex(new RegExp(`^${CurrencyCodeSchema.enum.USD}|${CurrencyCodeSchema.enum.EUR}|${CurrencyCodeSchema.enum.GBP}-[0-9]+$`));

try {
  const validCurrency = FormattedCurrencyStringSchema.parse("USD-100");
  console.log("Valid Currency:", validCurrency);
} catch (error) {
  console.error("Invalid Currency:", error);
}

try {
    const invalidCurrency = FormattedCurrencyStringSchema.parse("CAD-50");
    console.log("Valid Currency:", invalidCurrency); //This won't execute if parse fails.
  } catch (error) {
    console.error("Invalid Currency:", error);
  }


            

              
                Copy
              
            
          

રનટાઇમ વેલિડેશન માટે શ્રેષ્ઠ પદ્ધતિઓ

રનટાઇમ વેલિડેશનનો અમલ કરતી વખતે, નીચેની શ્રેષ્ઠ પદ્ધતિઓને ધ્યાનમાં રાખો:

• સીમા પર વેલિડેટ કરો: ડેટા તમારી સિસ્ટમમાં પ્રવેશતાની સાથે જ તેને વેલિડેટ કરો (દા.ત., યુઝર ઇનપુટ, API રિસ્પોન્સ).
• સ્પષ્ટ ભૂલ સંદેશાઓ પ્રદાન કરો: વપરાશકર્તાઓને સમજવામાં મદદ કરવા માટે માહિતીપ્રદ ભૂલ સંદેશાઓ જનરેટ કરો કે તેમનું ઇનપુટ શા માટે અમાન્ય છે.
• એક સુસંગત વેલિડેશન વ્યૂહરચનાનો ઉપયોગ કરો: ડેટાની અખંડિતતા સુનિશ્ચિત કરવા માટે તમારી એપ્લિકેશનમાં એક સુસંગત વેલિડેશન વ્યૂહરચના અપનાવો.
• તમારા વેલિડેશન લોજિકનું પરીક્ષણ કરો: તમારા વેલિડેશન લોજિકનું સંપૂર્ણ પરીક્ષણ કરો જેથી ખાતરી થાય કે તે માન્ય અને અમાન્ય ડેટાને યોગ્ય રીતે ઓળખે છે.
• પર્ફોર્મન્સ અને સુરક્ષા વચ્ચે સંતુલન રાખો: તમારા વેલિડેશન લોજિકને પર્ફોર્મન્સ માટે ઓપ્ટિમાઇઝ કરો અને ખાતરી કરો કે તે સુરક્ષાની નબળાઈઓને અસરકારક રીતે અટકાવે છે. અત્યંત જટિલ રેજેક્સ ટાળો જે ડિનાયલ ઓફ સર્વિસ તરફ દોરી જાય છે.

આંતરરાષ્ટ્રીયકરણની વિચારણાઓ

વૈશ્વિક સંદર્ભમાં સ્ટ્રિંગ વેલિડેશન સાથે કામ કરતી વખતે, તમારે આંતરરાષ્ટ્રીયકરણ (i18n) અને સ્થાનિકીકરણ (l10n) ને ધ્યાનમાં લેવાની જરૂર છે. જુદા જુદા લોકેલ્સમાં સ્ટ્રિંગ્સને ફોર્મેટ કરવા માટે જુદા જુદા નિયમો હોઈ શકે છે, જેમ કે તારીખો, સંખ્યાઓ અને ચલણ મૂલ્યો.

ઉદાહરણ તરીકે, યુરો (€) માટે ચલણ પ્રતીક લોકેલના આધારે રકમની પહેલાં અથવા પછી દેખાઈ શકે છે. તેવી જ રીતે, દશાંશ વિભાજક સમયગાળો (.) અથવા અલ્પવિરામ (,) હોઈ શકે છે.

આ વિવિધતાઓને હેન્ડલ કરવા માટે, તમે Intl જેવી આંતરરાષ્ટ્રીયકરણ લાઇબ્રેરીઓનો ઉપયોગ કરી શકો છો, જે લોકેલ-સંવેદનશીલ ડેટાને ફોર્મેટ કરવા અને પાર્સ કરવા માટે APIs પ્રદાન કરે છે. ઉદાહરણ તરીકે, તમે વિવિધ કરન્સી ફોર્મેટ્સને હેન્ડલ કરવા માટે પાછલા ઉદાહરણને અનુકૂળ કરી શકો છો:

            
function isValidCurrencyString(currencyString: string, locale: string): boolean {
  try {
    const formatter = new Intl.NumberFormat(locale, { style: 'currency', currency: currencyString.substring(0,3) }); //Very basic example

    //Attempt to parse the currency using formatter. This example is intentionally very simple.
    return true;
  } catch (error) {
    return false;
  }
}

console.log(`USD-100 is valid for en-US: ${isValidCurrencyString('USD-100', 'en-US')}`);
console.log(`EUR-100 is valid for fr-FR: ${isValidCurrencyString('EUR-100', 'fr-FR')}`);

            

              
                Copy
              
            
          

આ કોડ સ્નિપેટ એક પાયાનું ઉદાહરણ પૂરું પાડે છે. યોગ્ય આંતરરાષ્ટ્રીયકરણ માટે વધુ સંપૂર્ણ હેન્ડલિંગની જરૂર છે, સંભવિતપણે બાહ્ય લાઇબ્રેરીઓ અથવા APIs નો ઉપયોગ કરવો જે ખાસ કરીને વિવિધ લોકેલ્સમાં કરન્સી ફોર્મેટિંગ અને વેલિડેશન માટે ડિઝાઇન કરવામાં આવી છે.

નિષ્કર્ષ

રનટાઇમ વેલિડેશન મજબૂત અને વિશ્વસનીય ટાઇપસ્ક્રિપ્ટ એપ્લિકેશન્સ બનાવવાનો એક આવશ્યક ભાગ છે. ટાઇપસ્ક્રિપ્ટના ટેમ્પલેટ લિટરલ ટાઇપ્સને રેગ્યુલર એક્સપ્રેશન્સ અથવા વૈકલ્પિક વેલિડેશન પદ્ધતિઓ સાથે જોડીને, તમે રનટાઇમ પર સ્ટ્રિંગ્સની માન્યતાની ચકાસણી માટે એક શક્તિશાળી એન્જિન બનાવી શકો છો.

આ અભિગમ ટાઇપ સેફ્ટીને વધારે છે, અનપેક્ષિત ભૂલોને અટકાવે છે અને તમારા કોડની એકંદર ગુણવત્તામાં સુધારો કરે છે. જેમ જેમ તમે વધુ જટિલ એપ્લિકેશન્સ બનાવો છો, તેમ તેમ તમારો ડેટા અપેક્ષિત ટાઇપ્સ અને ફોર્મેટ્સને અનુરૂપ છે તેની ખાતરી કરવા માટે રનટાઇમ વેલિડેશનને સમાવવાનું ધ્યાનમાં લો.

વધુ સંશોધન

• વધુ જટિલ વેલિડેશન સિનારિયોઝ માટે એડવાન્સ્ડ રેગ્યુલર એક્સપ્રેશન તકનીકોનું અન્વેષણ કરો.
• સ્કીમા-આધારિત વેલિડેશન માટે Zod અને Yup જેવી વેલિડેશન લાઇબ્રેરીઓની તપાસ કરો.
• ટાઇપસ્ક્રિપ્ટ ટાઇપ્સમાંથી આપમેળે વેલિડેશન ફંક્શન્સ જનરેટ કરવા માટે કોડ જનરેશન તકનીકોનો ઉપયોગ કરવાનું વિચારો.
• લોકેલ-સંવેદનશીલ ડેટાને હેન્ડલ કરવા માટે આંતરરાષ્ટ્રીયકરણ લાઇબ્રેરીઓ અને APIs નો અભ્યાસ કરો.